A digital communication system typically includes three portions: a transmitter, a channel and a receiver. The transmitter can perform channel encoding on an information sequence to obtain encoded words, interleave the encoded words, map the interleaved bits onto modulated symbols, and then process and transmit the modulated symbols based on communication channel information. The channel may have a particular channel response due to various factors such as multipath and movements, which makes the data transmission distorted. Moreover, noises and interferences may further deteriorate the data transmission. The receiver receives the modulated symbol data that has passed through the channel. In this case, the modulated symbol data has been distorted and some processing will be required before the original information sequence can be restored.
In accordance with the coding scheme used for the information sequence at the transmitter, the receiver can perform corresponding processing on the received data, so as to restore the original information sequence reliably. The coding scheme needs to be visible to both the transmitter and the receiver. In general, the coding processing scheme is Forward Error Correction (FEC) based coding, which adds some redundant information to the information sequence. The receiver can utilize the redundant information to restore the original information sequence reliably.
Some common FEC coding schemes include convolutional coding, turbo coding and LDPC coding. In an FEC coding process, a k-bit information sequence is FEC encoded into n-bit FEC encoded words (with n-k redundant bits), with an FEC coding rate of k/n. The convolutional coding can easily encode blocks having any arbitrary sizes. In the turbo coding, different sizes of information sequences can be supported by utilizing two encoding components used for processing the information sequence and a code interleaving scheme capable of supporting different sizes.
The LDPC coding is linear block coding that can be defined using a very sparse parity check matrix or a bipartite graph. Low complexity of encoding/decoding is made possible with the sparsity of the check matrix, such that the LDPC can be applicable in practice. It has been proven by various practices and theories that the LDPC coding is the channel coding having the optimal performance in an Additive White Gaussian Noise (AWGN) channel. Its performance is very close to the Shannon limit and is superior to those of the convolutional coding and turbo coding.
In particular, structured LDPC codes have become a mainstream application due to its structured feature. They have been widely applied in e.g., IEEE 802.11ac, IEEE 802.11ad, IEEE 802.11aj, IEEE 802.16e, IEEE 802.11n, DVB, microwave communications and optical fiber communications. Such structured LDPC codes have a parity check matrix H having mb×z rows and nb×z columns. It is composed of mb×nb block matrices. The respective block matrices represent different powers of a z×z basic permutation matrix and are cyclically shifted matrices of the identity matrix. The matrix H has the following form:
  H  =            [                                                  P                              h                00                b                                                                        P                              h                01                b                                                                        P                              h                02                b                                                          …                                              P                              h                                  0                  ⁢                                      n                    b                                                  b                                                                                        P                              h                10                b                                                                        P                              h                11                b                                                                        P                              h                12                b                                                          …                                              P                              h                                  1                  ⁢                                      n                    b                                                  b                                                                          …                                …                                …                                …                                …                                                              P                              h                                                      m                    b                                    ⁢                  0                                b                                                                        P                              h                                                      m                    b                                    ⁢                  1                                b                                                                        P                              h                                                      m                    b                                    ⁢                  2                                b                                                          …                                              P                              h                                                      m                    b                                    ⁢                                      n                    b                                                  b                                                        ]        =          P              H        b            
Let hijb=−1, Phijb=0, which is an all-zero matrix. If hijb is an integer larger than or equal to 0, let Phijb=(Phijb), where P is a z×z standard permutation matrix, as follows:
  P  =            [                                    0                                1                                0                                …                                0                                                0                                0                                1                                …                                0                                                …                                …                                …                                …                                …                                                0                                0                                0                                …                                1                                                1                                0                                0                                …                                0                              ]        .  
In this way, the exponent hijb can uniquely identify each block matrix. If a block matrix is an all-zero matrix, generally it can be represented as −1. If a block matrix is obtained by cyclically shifting the identity matrix by s, hijb equals to s. Thus, all ‘hijb’s can constitute a basic check matrix Hb. z indicates the number of dimensions of the standard permutation matrix and is referred to as expansion factor herein. In this case, the structure LDPC codes can be uniquely determined from the basic check matrix Hb and the expansion factor z. The basic check matrix Hb has several parameters: mb nb and kb, where mb is the number of rows of the basic check matrix (or the number of check columns of the basic check matrix), nb is the number of columns of the basic check matrix, and kb=nb−mb is the number of system columns of the basic check matrix.
For example, when a basic check matrix Hb (with 2 rows and 4 columns) is as follows and the expansion factor z equals to 4:
      [                            0                          1                          0                                      -            1                                                2                          1                          2                          1                      ]    ,the parity check matrix will be:
  H  =            [                                    1                                0                                0                                0                                0                                0                                0                                1                                1                                0                                0                                0                                0                                0                                0                                0                                                0                                1                                0                                0                                1                                0                                0                                0                                0                                1                                0                                0                                0                                0                                0                                0                                                0                                0                                1                                0                                0                                1                                0                                0                                0                                0                                1                                0                                0                                0                                0                                0                                                0                                0                                0                                1                                0                                0                                1                                0                                0                                0                                0                                1                                0                                0                                0                                0                                                0                                0                                1                                0                                0                                0                                0                                1                                0                                0                                1                                0                                0                                0                                0                                1                                                0                                0                                0                                1                                1                                0                                0                                0                                0                                0                                0                                1                                1                                0                                0                                0                                                1                                0                                0                                0                                0                                1                                0                                0                                1                                0                                0                                0                                0                                1                                0                                0                                                0                                1                                0                                0                                0                                0                                1                                0                                0                                1                                0                                0                                0                                0                                1                                0                              ]        .  
Layered decoding, i.e., a partially parallel decoding scheme, can be applied to the LPDC codes. The above parity check matrix has 8 rows, which means there are 8 parity check codes. In decoding, each parity check matrix needs to be decoded individually. Data updates being completed for all the 8 parity check codes is referred to as one iteration. During each iteration, if the partially parallel (i.e., layered) decoding is utilized, e.g., with a degree of parallelism, p, meaning that p parity check codes are updated in parallel, the current and next p parity check codes will operate using the same updating module. In this case, the complexity of the decoder can be much lower. Moreover, in the layered decoding, the currently updated data can be used for updating the data at the next layer, which means a smaller number of iterations will be required and the decoding throughput will be higher. For the above H as an example, if the degree of parallelism is 2, then for every 4 rows of the parity check matrix (one row of the basic check matrix), two (the degree of parallelism) of the parity check codes will be updated in parallel.
In general, the parity check matrix could be very large and difficult to store and process. It would be much easier to store the basic check matrix.
According to fundamental mathematical knowledge, there are an infinite number of prime numbers. A prime number is a natural number greater than 1 that cannot be formed by multiplying two smaller natural numbers. Typically, a prime number is an integer larger than 1, e.g., 2, 3, 5, 7, 11, 13, 17, 19 and so on.
In almost all FEC coding methods, the encoder has a relatively low complexity and the complexity lies basically in the decoder at the receiver. The LDPC coding has a higher decoding speed and throughput as it has the parallelism feature such that the parallel decoding can be applied. However, typically the basic check matrix for the LDPC codes can only be adapted to particular lengths and it may not be easy to accommodate various, flexible lengths of code blocks. It will be more complicated to accommodate different lengths of code blocks.
There are currently no effective solutions to the problem in the related art associated with low flexibility in data sequence processing with LDPC coding.